home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Development Tools & Languages / Macintosh Common Lisp Related / User Contributions / zebu v3.3.3 (LALR parser) / test / regex-test.lisp < prev    next >
Encoding:
Text File  |  1994-09-12  |  5.2 KB  |  189 lines  |  [TEXT/ttxt]
  1. ; -*- mode:     CL -*- ----------------------------------------------------- ;
  2. ; File:         regex-test.lisp
  3. ; Description:  some tests for the regular expression compiler
  4. ; Author:       Joachim H. Laubsch
  5. ; Created:       9-Feb-93
  6. ; Modified:     Tue Apr 19 16:38:35 1994 (Joachim H. Laubsch)
  7. ; Language:     CL
  8. ; Package:      ZEBU
  9. ; Status:       Experimental (Do Not Distribute) 
  10. ; RCS $Header: $
  11. ;
  12. ; (c) Copyright 1993, Hewlett-Packard Company
  13. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  14. ; Revisions:
  15. ; RCS $Log: $
  16. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  17. (in-package "ZEBU")
  18. (setq *regex-debug* nil)
  19. (defun match-beginning (n)
  20.   (first (AREF *REGEX-GROUPS* n)))
  21.  
  22. (defun match-end (n)
  23.   (second (AREF *REGEX-GROUPS* n)))
  24.  
  25. (defun regex-test (n pat string result &key invert)
  26.   (declare (special STRING))
  27.   (let ((form `(progn .,(regex-compile pat)))
  28.     *print-circle*
  29.     (START 0)
  30.     (END (LENGTH STRING)))
  31.     (declare (special START END))
  32.     (princ ".")
  33.     (setf *foo* form)
  34.     (if (eval form)
  35.     (let ((matched-string (subseq string 0 (match-end 0))))
  36.       (if (string= matched-string result)
  37.           (if invert
  38.           (warn "In ~S ~A did not match correctly" n pat)
  39.         t)
  40.         (if invert
  41.         t
  42.           (warn "In ~S ~A did not match correctly~%Only ~S was matched!"
  43.             n pat matched-string))))
  44.       (if invert
  45.       t
  46.     (warn "In ~S ~A did not compile correctly" n pat)))))
  47.        
  48. (regex-test 1 "\\(na\\)x+\\1" "naxna" "naxna")
  49. (regex-test 2 "\\(na\\)x+\\1" "naxna123" "naxna")
  50.  
  51. (regex-test 3 "\\(na\\)x+" "naxxos" "naxx")
  52. (regex-test 4 "\\(na\\)x+" "naxos" "nax")
  53. (regex-test 5 "\\(na\\)x+" "naos" "na" :invert t)
  54.  
  55. (regex-test 6 "\\(na\\)x*" "naxxos" "naxx")
  56. (regex-test 7 "\\(na\\)x*" "naxos" "nax")
  57. (regex-test 8 "\\(na\\)x*" "naos" "na")
  58.  
  59. (regex-test 9 "[0-9]+" "123ab" "123")
  60. (regex-test 10 "[a-zA-Z]+" "aAbb123" "aAbb")
  61. (regex-test 11 "[0-9a-z]+" "1234&&*" "1234")
  62. (regex-test 12 "[0-9a-z]+" "1234a&&*" "1234a")
  63.  
  64. (regex-test 13 "[0-9a-zA-Z]+" "a1234a" "a1234a")
  65. (regex-test 14 "[0-9a-zA-Z&]+" "aAbb123&&*" "aAbb123&&")
  66.  
  67. (regex-test 15 "[0-9]+\\.[0-9]*" "0.123cm" "0.123")
  68.  
  69. (regex-test 16 "{[^}\\n]*}"
  70.         "{M.D. Harrison and A. Monk (Ed.)} \n\t foo: 2"
  71.         "{M.D. Harrison and A. Monk (Ed.)}")
  72.  
  73. (regex-test 17 "{[^}\\n]*}"
  74.         "{M.D. Harrison and
  75. A. Monk (Ed.)} \n\t foo: 2"
  76.         "{M.D. Harrison and A. Monk (Ed.)}" :invert t)
  77.  
  78.  
  79. (regex-test 18 "{[^}\\n]*}"
  80.         "{M.D. Harrison and {A. Monk} (Ed.)} \n\t foo: 2"
  81.         "{M.D. Harrison and {A. Monk} (Ed.)}" :invert t)
  82.  
  83. (regex-test 19 "ca?r" "car" "car")
  84.  
  85. (regex-test 20 "ca?r" "cr" "cr")
  86.  
  87. (regex-test 21 "c[ad]+r" "caaar" "caaar")
  88.  
  89. (regex-test 22 "c[ad]+r" "caaar aa1" "caaar")
  90.  
  91. (regex-test 23 "c[ad]+r$" "caaar" "caaar")
  92.  
  93. (regex-test 24 ".*" "" "")
  94.  
  95. (regex-test 25 ".*" "aa" "aa")
  96.  
  97. (regex-test 26 ".*" "aa" "aa")
  98.  
  99. (regex-test 27 "c[ad]?r" "cr" "cr")
  100.  
  101. (regex-test 28 "c[ad]?r" "car" "car")
  102.  
  103. (regex-test 29 "c[ad]?r" "cdr" "cdr")
  104.  
  105. (regex-test 30 "c[0-9]?r" "cr" "cr")
  106.  
  107. (regex-test 31 "c[0-9]?r" "c9rxx" "c9r")
  108.  
  109. (regex-test 32 "c[0-9]?r" "crxx" "cr")
  110.  
  111.  
  112. ;;(regex-test 27 "a\\|b" "a" "a")
  113. ;;(pprint *foo*)
  114.  
  115. (regex-test 33 "ab.yz" "ab yz" "ab yz")
  116.  
  117. (regex-test 34 "ab.yz" "ab
  118. yz" "ab" :invert t)
  119.  
  120. (regex-test 35 "\\(abc\\)\\1" "abcabc" "abcabc")
  121.  
  122. (regex-test 36 "\\(abc\\)\\1x*\\(def\\)y*\\2" "abcabcxxxxdefyyyyyyydef$%%%%%"
  123.         "abcabcxxxxdefyyyyyyydef")
  124.  
  125. ;;(regex-test 37 "a|bc*" "a" "a")
  126.  
  127. (let ((fn (def-regex-parser 'Natural_Number "[0-9]+")))
  128.   (pprint fn)
  129.   (compile (eval fn)))
  130.  
  131. (defun regex-test1 (number fn input output &optional invert)
  132.   (let* ((match (funcall fn input))
  133.      (test (and match
  134.             (> match 0)
  135.             (= (parse-integer
  136.             (subseq input (match-beginning 0) (match-end 0)))
  137.                output))))
  138.     (if (if invert (not test) test) 
  139.     (princ ".")
  140.       (warn "wrong match in ~d" number))
  141.     (values)))
  142.  
  143. (regex-test1 40 'Natural_Number "111" 111)
  144.  
  145. (regex-test1 41 'Natural_Number "111 af" 111)
  146.  
  147. (regex-test1 42 'Natural_Number "a111z" 0 t)
  148.  
  149. (let ((fn (def-regex-parser 'Natural_Number* "[0-9]*")))
  150.   ;; (pprint fn)
  151.   (eval fn))
  152.  
  153. (regex-test1 43 'Natural_Number* "111" 111)
  154. (regex-test1 44 'Natural_Number* "111 af" 111)
  155. (regex-test1 45 'Natural_Number* "a111z" 0 t)
  156.  
  157. (unless (equal (Natural_Number "11aab" 0 4) 2)
  158.   (warn "No match"))
  159.  
  160. (unless (equal (Natural_Number "11aab" 1 4) 2)
  161.   (warn "No match"))
  162.  
  163. (when (equal (Natural_Number "1aab" 1 4) 2)
  164.   (warn "wrong match"))
  165.  
  166. (let ((fn (def-regex-parser 'd_seq "d+")))
  167.   (eval fn))
  168.  
  169. (let ((fn (def-regex-parser 'd_seq* "d*")))
  170.   (eval fn))
  171.  
  172. (eval (def-regex-parser 'Rest_of_line ".+\$"))
  173. (let* ((s "abcdef") (n (length s)))
  174.   (unless (equal (REST_OF_LINE s 1 n) n)
  175.     (warn "Rest_of_line did not compile correctly")))
  176.  
  177. (eval (def-regex-parser 'Quotation-Rx "'[^']+'"))
  178. (Quotation-Rx "'System 0x40147bb8 [sys_specs_Mfake]' provides no alternatives for allocating resource 'max_cpu_Rspu'")
  179.  
  180. (eval (def-regex-parser 'NatNumber "-?[0-9]+[^a-zA-Z/$+_.:]"))
  181. (eval (def-regex-parser 'NatNumber "-?[0-9]+[^a-zA-Z]"))
  182.  
  183. (NATNUMBER "32mb_mem_array")
  184.  
  185. (regex-test 50 "[A-Z]+" "ABCY" "ABCY")
  186. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  187. ;;                           End of regex-test.lisp
  188. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  189.